Process grouping for improved cache and memory affinity

ABSTRACT

Embodiments include determining a set of two or more processes that share at least one of a plurality of resources in a multi-node system in which the processes are running, wherein each of the set of two or more processes is running one different nodes of the multi-node system. For each combination of the set of processes and the resources, a value is calculated based, at least in part, on a weight of the resource and frequency of access of the resource by each process of the set of processes. The pair of processes having a greatest sum of calculated values by resource is determined. A first process of the pair of processes is allocated from a first node in the multi-node system to a second node in the multi-node system that hoses a second process of the pair of processes.

RELATED APPLICATIONS

This application is a Continuation application that claims benefit ofU.S. patent application Ser. No. 13/884,541 filed May 9, 2013, which isa 371 of the PCT International Application No. PCT/IB2012/050682 filedFeb. 15, 2012, which claims priority to European Patent Application No.11165537, filed May 10, 2011.

FIELD

Embodiments of the inventive subject matter relate generally to thefield of computers and computer systems. More particularly, theembodiments of the inventive subject matter relate to the allocation ofprocesses to individual processors (nodes) in multiprocessor systems.

BACKGROUND ART

Modern computer systems with many processors often have non-uniformmemory access (NUMA) properties; that is, the cost of accessing data inmemory is dependent on the physical location of the memory in relationto the processor which accesses it. As a result, performanceimprovements can often be gained by running an application on a limitednumber of processors and allocating memory which is local to thoseprocessors, thereby reducing or eliminating the need for costly remotememory accesses. Similarly, multiple threads which frequently access andmodify areas of memory which are shared with other threads can benefitfrom keeping all users of that memory close together, to reduce theamount of cross-node traffic to obtain cache lines which exist in thecache of a remote processor. These two issues can be referred to asmemory affinity and cache affinity.

Placing processes in order to increase the benefits of memory and cacheaffinity typically conflicts with the more general desire to balancework across all available resources of the whole system; clearly,placing all work onto a single node and allocating all memory locallywill increase cache and memory affinity, but in general will not providegood performance for all workloads, due to the increased contention forresources on that node. It is therefore desirable to identify taskswhich can benefit from memory and cache affinity and group themtogether, such that a group of related tasks will tend to run closertogether, but that unrelated tasks may be placed across other parts ofthe system.

There are several existing techniques for identifying this grouping, allof which have drawbacks.

1. Have no automatic grouping of tasks performed by the operatingsystem, but allow the user to group tasks and bind them to specificsystem resources. This approach relies heavily on the user understandingthe behaviour of the workloads and the architecture of the system, andis both time consuming and error prone. Such manual bindings alsotypically restrict the operating system's load balancing capabilities,thus making it less responsive to changes in load.

2. Have the operating system attempt to group threads of the sameprocess together, but treat processes as separate entities. This canprovide significant benefit for some workloads, as threads of the sameprocess will (in most operating systems) share the same address spaceand are likely to have considerable overlap in the working set of dataused by the threads. However, this approach alone does not account forgroupings of multiple processes, which means a significant potentialbenefit is not catered for.

What is required, therefore, is a means to identify groups of processesthat can benefit from cache and memory affinity without suffering fromthese drawbacks.

It should be noted that the term “multiprocessor” as used hereinencompasses dual- and multi-core processor devices, as well as multiplehardware thread and multiple CPU systems.

Systems exist which seek to address some of the above issues relates toa method for improving the execution efficiency of frequentlycommunicating processes utilising affinity scheduling by identifying andassigning the frequently communicating processes to the same processor.The system is based on counting “wakeup” requests between twoprocessors: a wakeup request occurs when a first process requiringinformation from a second process is placed in a sleep state until thesecond process is able to provide the required information, at whichpoint the first process is awoken. A count of the number of wakeuprequests between the pair of processes is maintained and, when apredetermined threshold is reached, the two processes are assigned tothe same processor for execution. Whilst this allocation can improveperformance, the determination is non-optimal, as will be describedbelow.

It is therefore an object of embodiments of the inventive subject matterto provide a means for providing an improved allocation of processes toprocessors in a multiprocessor system and, in particular, a meanscapable of identifying and addressing potential conflict issues beforethey arise.

Summary of Some Embodiments

In accordance with a first aspect of some embodiments there is provideda multiprocessor computer system, comprising:

a plurality of processor nodes;

at least one process memory storing a plurality of processes, each runby an allocated one of said plurality of processor nodes;

a plurality of system resources accessible by one or more of saidprocesses; and

a process allocation controller arranged to:

generate process-resource indicators representative of actual orpotential access by each process to one or more predetermined ones ofsaid plurality of resources;

identify as related, groups of processes sharing one or more resources;

apply a prioritization metric to indicators of a group of relatedprocesses to determine a pair of those processes having the highestpriority; and allocate the highest priority pair of processes to asingle processor node.

In such a multiprocessor computer system, the process allocationcontroller is preferably further arranged to apply the prioritizationmetric to identify a pair of those processes having a second highestpriority and allocate one or both of those processes to the said singleprocessor node if not already so allocated. Preferably, the system wouldrepeat the procedure a number of times until the node is optimallyloaded, for example with as many processes as can be handled withoutadversely affecting performance.

The arrangement of the preceding paragraph assumes that at least one ofthe second highest priority pair is related to a process of the highestpriority pair, leading to their housing on a common node. However, aswill be understood, if there is no shared relationship between theprocesses of the two pairs, the second highest pair may suitably beallocated to a different node, leaving space on the first node for anyfurther processes related to the highest priority pair.

A typical configuration of multiprocessor computer system has some ofthe processor nodes positioned in close physical proximity to each otherand others spaced further apart. In such an arrangement, the processallocation controller may be further arranged to allocate processes of arelated group to closely positioned processor nodes if their combinedprocessing requirement indicates that they cannot be accommodated bysingle processor node. This also allows those processes not identifiedas a member of a related group to be allocated to the more “remote”processors of the system to both spread the load and leave space forallocation of future processes that may be related to an existing group.

Such a typical configuration may also comprise a plurality of localmemories associated with the processing nodes, either one memory perprocessor or one memory shared between a small group of closelypositioned processors. In such an arrangement, where a process has datastored in a local memory associated with a particular processor nodehandling that process, the process allocation controller may suitably befurther arranged to migrate said data to the respectively associatedmemory when that process is moved to another processor node as a resultof allocation following application of the prioritization metric.

Suitably, the process allocation controller may be arranged to generateprocess-resource indicators by, for each of a plurality of processes andeach of a plurality of system resources, periodically polling the systemand then processing the poll results to identify links betweenindividual processes and individual resources.

The, or each of the one or more predetermined resources may be selectedfrom the group comprising memory regions, pipes, sockets, semaphores,memory queues, and unmodified Copy-On-Write pages. This is not anexclusive list and other resources may be included.

Also in accordance with some embodiments of the inventive subject matterthere is provided a method for assigning processes to processor nodes ina multiprocessor computer system having a plurality of resourcesaccessible by the processes, comprising causing the system to performthe steps of:

generating process-resource indicators representative of actual orpotential access by each process to one or more predetermined ones ofsaid plurality of resources;

identifying as related, groups of processes sharing one or moreresources;

applying a prioritization metric to indicators of a group of relatedprocesses to determine a pair of those processes having the highestpriority; and

allocating the highest priority pair of processes to a single processornode.

The method may further comprise, through application of theprioritization metric, identifying a pair of those processes having asecond highest priority and allocating one or both of those processes tothe said single processor node if not already so allocated. This may beextended to include determining processor requirements of each processassigned to a particular processor, and preventing the assignment offurther processes to the said processor which would otherwise result inexceeding the processing capability of that particular processor. Asmentioned above, if related processes cannot be accommodated by the sameprocessor node, performance improvements can still be attained byallocating those processes to physically proximate nodes, especially ifthose nodes have a shared local memory. Also, as above, if the processesof the second highest priority pair do not share a relationship witheither or both of the highest priority pair, they may beneficially beallocated to a different node.

The step of generating process-resource indicators may comprise, foreach of a plurality of processes and each of a plurality of systemresources, periodically polling the system to identify links betweenindividual processes and individual resources.

Where a process has data stored in a local memory associated with aprocessor handling that process, the method may further comprisemigrating that data when the associated process is moved to anotherprocessor as a result of allocation following application of theprioritization metric.

Within the prioritization metric, the individual system resources may beassigned a ranking, with the metric including this ranking indetermining the pair of processes having the highest priority. Forexample, shared access to a particular area of memory may be rated morehighly than a semaphore accessible by a pair of processes.

Where the step of generating process-resource indicators includesgenerating a numerical value for each, the method may further compriseapplying a threshold cut-off and excluding from application of theprioritization metric those indicators having a value below thethreshold. For example, a process that potentially only accesses aparticular resource once (perhaps at the distal end of a conditionaltree) would have a low value assigned to that process-resource indicatorand, by failing the threshold test, would not be considered for pairingon a processor node with a process that makes extensive use of theresource in question.

By using these techniques to identify groups of related processes, suchprocesses as may benefit from being placed close together can be groupedfor better performance, while other processes which for example, onlyshare a common parent need not be, allowing more opportunities to placethose processes on under-utilized nodes of the system, and allowing morecapacity to locate future processes near those processes with whom theydo share. As this is conducted automatically, no burden is placed on theuser to understand the detailed behaviour of the applications and thesystem.

This approach also allows the identification of processes which shareresources but have no immediate common ancestor. For example, a databasecontroller may choose to communicate with a process reading the databasevia a shared memory segment, but the database and the reader process maynot be obviously related other than by this shared memory. It isunlikely either that the reader process would have created the database,or that the database would have created the process that reads from it.However, through application of embodiments of the inventive subjectmatter, the detection of the shared resource (memory segment) wouldresult in the database controller and reader being handled by a sharednode, significantly improving access performance for the reader.

Some embodiments further provide a computer program stored on a computerreadable medium and loadable into the internal memory of a digitalcomputer, comprising software code portions, when said program is run ona computer, for performing the method according to some embodiments ofthe inventive subject matter as described above.

The summary of some embodiments does not recite all the necessaryfeatures of the inventive subject matter, and sub-combinations of thosefeatures may also encompass the inventive subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

Some embodiments of the inventive subject matter will now be described,by way of example only, with reference to preferred embodiments, asillustrated in the following figures, in which:

FIG. 1 is a block schematic diagram of the components of amultiprocessor computer system according to some embodiments of theinventive subject matter;

FIG. 2 is a further schematic representation of functional components ofa multiprocessor system supporting automatic allocation of processes;

FIG. 3 is a flow chart showing example operations for a method ofprocess allocation;

FIG. 4 is a flow chart representation of example operations for processallocation based on derived process-resource indicators;

FIG. 5 is an example table of values illustrating process-resourceindicator selection; and

FIG. 6 is a flow chart representation of example operations for anallocation metric applied to the table of FIG. 5.

DESCRIPTION OF EMBODIMENT(S)

FIG. 1 schematically represents the components of a computer systemsuitable to some embodiments of the inventive subject matter. A firstprocessor CPU 10 is coupled with random access memory RAM 12 and readonly memory ROM 14 by an address and data bus 16. As will be understood,and as will be described below, CPU 10 may comprise a cluster ofprocessors (nodes) with individual processes and/or process threadsbeing handled by individual nodes. Also connected to CPU 10 via theaddress and data bus 16 is at least one further processor 42 (or clusterof nodes), which may be a further CPU sharing tasks with the first CPU10, or may be a coprocessor device supplementing the function of the CPU10, handling processes such as floating point arithmetic, graphicsprocessing, signal processing and encryption. Each of these internalhardware devices 10, 12, 14, 42 includes a respective interface (notshown) supporting connection to the bus 16. These interfaces areconventional in form and need not be described in further detail.

Also connected to the CPU 10 via bus 16 are a number of externalhardware device interface stages (generally denoted 18). A firstinterface stage 20 supports the connection of external input/outputdevices, such as a mouse 22 and/or keyboard 24. A second interface stage26 supports the connection of external output devices such as a displayscreen 28 and/or audio output device 30, such as headphones or speakers.A third interface stage 32 supports the connection to external datastorage devices in the form of computer readable media: such externalstorage may as shown be provided by a removable optical or magnetic disc34 (accessed by a suitably configured disc reader 36). Alternatively oradditionally the external storage may be in the form of a solid statememory device such as an extension drive or memory stick. The externalstorage may contain a computer program, containing program software codeportions which, when run by the CPU 10 and/or further processor 42,perform the method according to some embodiments of the inventivesubject matter. A fourth interface stage 38 supports connection of thesystem to remote devices or systems via wired or wireless networks 40,for example over a local area network LAN or via the internet.

The CPU 10 and further processor 42 may be of many different types, fromdifferent manufacturers, and based on different instructions setarchitectures (ISAs), although for ease of process allocation, it ispreferred that the nodes of a cluster are identical devices.

FIG. 2 schematically represents components of a multiprocessor systemarranged to automatically allocate processes to processors. A firstcluster 10A of processors (nodes) 50, 52, 54 is connected via a bus 56and program cache controller (PCC) 58 to a local memory device, cache60. A second cluster 42A of nodes 70, 72, 74 is connected via a bus 76and PCC 78 to a further cache 80. Although shown as sharing caches, itwill be understood that in an alternative arrangement each node may haveits own cache: this would generally increase the efficiency of the node,but may incur penalties through an increase in remote cache accessesrequired across the system.

Coupled with the clusters 10A, 42A and the associated PCC and caches isa process controller 82 linked with a process memory 84. The processmemory 84, which may comprise an area of ROM 14 (FIG. 1), stores alibrary of processes to be run by respectively allocated nodes. Asdiscussed above, it is an aim of multiprocessor systems to balance theprocess load across the available nodes, whilst placing related tasks inclose proximity. In the example of FIG. 2, if a pair of processes arerespectively being run on nodes 50 and 72, which processes access commonsystem resources, there would either be unnecessary duplication of datain caches 60, 80, or delays introduced due to remote cache calls as anode seeks to access data in the cache of another cluster.

In some embodiments, such related processes are identified. Unlike inmost existing techniques for placing related workloads close together,this identification can be performed after process creation, as it isnot necessary to make a final placement decision at process creationtime. Instead, this identification may be performed by a separatefunction in the operating system, or by a separate user space process,rather than by the operating system (OS) scheduler itself. Once a groupof two or more related processes is identified, processes may be movedto the same node and optionally, their memory may be migrated to that ofthe node, that is to say to the cache of the individual node or nodecluster.

In the example of FIG. 2, a process allocation controller (PAC) 86 iscoupled with the process controller 82 and both have access to thesystem resources, indicated generally at 88. The PAC 86 is arranged toperform the functions of:

generating process-resource indicators representative of actual orpotential access by each process to one or more predetermined ones ofsaid plurality of resources;

identifying as related, groups of processes sharing one or moreresources;

applying a prioritization metric to indicators of a group of relatedprocesses to determine a pair of those processes having the highestpriority; and

allocating the highest priority pair of processes to a single processornode, as will be described in further detail below. These indicatorsinclude (but are not limited to):

shared memory regions 90 to which each process is attached;

pipes or sockets 92 which are open by both processes;

semaphores 94 accessible by both processes;

shared message queues 96;

unmodified Copy-On-Write pages 98; that is, pages which are logicallyseparate but which will be mapped to the same physical page until oneprocess modifies them.

The steps of the method for assigning processes to processor nodes in amultiprocessor computer system are directed by the PAC 86 and, asgenerally illustrated by the flowchart of FIG. 3, begin at step 100 withcausing the system to generate process-resource indicatorsrepresentative of actual or potential access by each process to one ormore of the system resources. Next, at step 102, groups of processessharing one or more resources are identified as a related group. At step104 a prioritization metric is applied to the indicators of a group ofrelated processes to determine a pair of those processes having thehighest priority. At step 106, the highest priority pair of processesare allocated to a single processor node, and at step 112 a check ismade as to whether there are further members of the related group whichcan be added to the node: if so, the procedure reverts to step 106, elseit ends at 114.

As will be described below, the step 104 of applying the prioritizationmetric may further include applying a weighting (step 108) to thecollected indicators and/or applying a threshold cut-off (step 110) toreduce the number of indicators to be further processed.

FIG. 4 represents one possible method for handling the allocation ofprocesses to nodes when a group of related processes has beenidentified. The process starts at step 120 with the selection of a firstprocess P1 of the highest priority pair. At step 122, the node on whichthat process P1 runs is identified and, at step 124, the availablecapacity of that node to handle further processes is determined. At step126, the next process of the group (initially the second process of thehighest priority pair) is selected and, at step 128, a check is made asto whether the node has the capability to also handle the newly-selectedprocess. If so, at step 130, this process is assigned to the node.

As mentioned above, when a process is migrated to a node, optionally itsmemory may be migrated at step 132. Referring back to FIG. 2, it will beappreciated that a process being migrated from node 54 to node 50 willnot generally require memory migration as the two processes alreadyshare a cache 60.

Returning to FIG. 4, having assigned the second process to the node, acheck is made at step 134 as to whether there are further processes inthe group. If there are not, the procedure ends at step 136. If step 134identifies further processes in the group, the procedure reverts to step126 at which the next process is selected.

If the test at step 128 indicates that there is insufficient capacity inthe node under consideration, the procedure moves to step 138 at which adetermination is made as to whether there is an available node (one withavailable capacity) in close physical proximity to the node underconsideration. Reverting to FIG. 2, if the PAC 86 determines that aprocess currently running on node 74 in cluster 42A is ideally to bemigrated to node 50 in cluster 10A but there is insufficient capacity innode 50 to handle the additional process, useful benefits still arise ifthe process can instead be migrated to node 52 as this shares a cache 60with the originally intended target node 50.

Returning to FIG. 4, if the test at step 138 identifies that there is anearby node with capacity then, at step 140, the process is migrated tothis nearby node. Following this, at step 142, any further processes ofthe related group are handled in like manner to steps 126, 128, 130,132, 134 but with the nearby node as the chosen destination. In arefinement to the procedure, the further processes of the related groupmay still be checked against the original target node as it may be thecase that they have lower requirements which can be met by the originalnode.

Lastly, if the test at step 138 does not identify a suitable nearby nodeto handle the “overspill” from the first node, the procedure ends atstep 138. It would usually be inappropriate to force processes ontonodes that are unable to handle them efficiently, which is the reasonfor the procedure end in this example. However, in some cases it may bedetectable that the benefit to performance to be obtained by groupingthe processes outweighs the cost of overloading the node, and in suchcases the node capacity is exceeded.

One possible way of conducting the identification of process-resourcepairs, to enable the formation of a group of related processes, would beto periodically poll the list of processes on the system. For eachprocess, a list is collected of indicators representing ‘interesting’resources it uses. An example of such a list is discussed below withreference to FIG. 5.

To gather further evidence of the significance of these indicators,statistics may be collected by the operating system on such resourceusage; for example, the number of times a pipe has been read from orwritten to, or the number of accesses made to shared memory (on someprocessor architectures, this last piece of data may be expensive tocollect: however, some processor architectures may have specifichardware support for such detection and/or may allow identification offrequently accessed pages without resorting to page protection and pagefault counting).

Having gathered this data for all processes (or at least, all processeswith a resource consumption large enough to warrant it; potentially onlythe N most frequently accessing processes would be considered), eachprocess-resource pair can be assigned a relative priority(process-resource indicator value). This can be based on both a staticpriority given to different types of resource sharing (for example,shared memory may be treated as more important than a shared messagequeue) and any detailed statistics gathered about the use of eachresource. This priority would show which resource uses would offer themost benefit from having the accessing processes placed locally.

FIG. 5 is a table showing, in greatly simplified form, data that may becollected in support of the allocation process. The first columncontains a numerical identifier for each of the three processesconsidered. The second column contains a numerical identifier for eachof the four system resources considered. The third column indicates thenumber of accesses to the resource by the process. The fourth columnindicates a weighting value to be used in the determination of a finalnumerical score, given in column five. As previously mentioned, someresources may be treated as being more important than others: in thisexample, resource 1 (for example a shared memory) has a weighting of 3whilst resource 3 (for example a shared message queue) has a weightingof 1.

In this simplistic example, the resulting priority score for eachindicator (process-resource indicator) may be obtained by application ofan allocation metric as represented in flow chart form in FIG. 6. Thefirst step 150 is to obtain the number of accesses from column three ofthe table stored in memory 152. This is followed by obtaining theweighting from column four in step 154. At step 156, the number ofaccesses and the weighting are multiplied and the result entered incolumn 5 of the table in memory 152. At step 158, a check is made as towhether there are unprocessed results in the table. If so, the procedurereverts to steps 150 and 154 in which the next pair of access count andweighting are obtained followed by multiplication (step 156) and addingto the stored data.

If the check at step 158 shows that all values in columns three and fourhave been processed, the procedure moves to step 160 where the score forprocess pairs 1 and 2, 2 and 3, and 3 and 1 based on each of theresources they share, are compared to identify the highest combinedprocess-resource score. The result of this indicates that the highestpriority pair of processes is 1 and 3 through their shared use ofresource 1, giving an aggregate score of 21. Consequently, in allocationstep 162, processes 1 and 3 will be migrated by the system to a commonnode (commonly one of the two nodes to which the pair are currentlyallocated). Lastly, at step 164, the next highest scoring pair (whichwill typically involve one of the initial pair) are processed. Repeatingthe analysis of steps 150 to 160 will show processes 2 and 3 as the nexthighest scoring pair (with a score of 12 through resource 4). As process2 has already been migrated, a check (as at step 124 in FIG. 4) willdetermine whether there is sufficient capacity on the first node to alsomigrate process 3 or at least capacity on a closely proximate node.

In a practical implementation, for each process-resource pair with apriority above a specified threshold (or alternatively, for all pairs,though searching the whole space may prove expensive), a search is madeto see if any other process shares the resource. This information isthen used to build a graph of processes, in which the arcs betweenprocesses are annotated with the priority of that shared resource ascalculated earlier.

If groups of processes are found for which significant sharing isobserved, the arc with the highest priority is picked and the twoprocesses that it connects are placed on the same node in the system. Aslong as there is more space on that node to place additional work, thegraph is traversed from the initial processes by following the arcs withthe next highest priority from those processes which are already placed.When the node becomes full (that is to say enough processes have beenplaced to make full use of CPU resources) all remaining arcs betweenplaced and unplaced processes are removed. This procedure can then berepeated with the remaining processes in the graph, placing them on thenext available node of the system.

While some embodiments have been described above, the technical scope ofthe inventive subject matter is not limited to the scope of theabove-described embodiments. It should be apparent to those skilled inthe art that various changes or improvements can be made to theembodiments.

For example, in terms of allocation of processes to nodes, the initialsteps of FIG. 4 may be modified such that the home nodes of bothprocesses of the highest priority pair are checked for availablecapacity to provide basis for a determination as to which process of thepair is to be moved. Indeed, such a check may indicate that bothprocesses are to be moved to a further node having the capacity tohandle the pair. Alternatively, or additionally, the decision as towhich of a pair to move may take account of which of the processes isbusier (more active) at the point of reallocation. A further (moreaggressive) option would be to pick the home node of either process,determine the capacity of that node and, if there is insufficientcapacity, move one or more other processes away from that node. Yet afurther option would be to perform a full reallocation of processes tonodes, starting from the assumption that the whole system is empty andthen placing processes one at a time according to where is free andwhich processes should be located together. In this last case, anyprocesses which are not identified as related may be placed on any nodehaving free space at the end of the allocation exercise.

It is apparent from the description of the appended claims thatimplementations including such changes or improvements are encompassedin the technical scope of the inventive subject matter.

What is claimed is:
 1. A method comprising: determining a set of two ormore processes of a plurality of processes that share at least one of aplurality of resources in a multi-node system in which the plurality ofprocesses are running, wherein each of the set of two or more processesis running on different nodes of the multi-node system; for eachcombination of the set of processes and the resources, calculating avalue based, at least in part, on a weight of the resource and frequencyof access of the resource by each process of the set of processes;determining a pair of processes of the set of processes having agreatest sum of calculated values by resource; and allocating a firstprocess of the pair of processes from a first node in the multi-nodesystem to a second node in the multi-node system that hosts a secondprocess of the pair of processes.
 2. The method of claim 1, furthercomprising: determining that the first process has a lower calculatedvalue that constitutes the greatest sum than the second process, whereinsaid allocating the first process from the first node to the second nodeis based on said determining that the first process has a lowercalculated value that constitutes the greatest sum than the secondprocess.
 3. The method of claim 1, further comprising: determining whichof the sets of processes do not have at least one calculated valuebeyond a threshold and excluding those from further consideration forallocation.
 4. The method of claim 1, further comprising: determining athird process of the set of processes having a next greatest sum ofvalues by resource; determining a capacity of the second node; and inresponse to determining that allocation of the third process to thesecond node will not exceed the capacity of the second node, allocatingthe third process to the second node in the multi-node system that hoststhe second process of the pair of processes; in response to determiningthat allocation of the third process to the second node will exceed thecapacity of the second node, allocating the third process to a thirdnode in the multi-node system, wherein the third node is in spatialproximity to the second node.
 5. The method of claim 1, furthercomprising: periodically aggregating data, wherein the data indicate theweight of the resource and frequency of access of the resource by eachprocess of the set of processes.
 6. The method of claim 1, wherein theplurality of resources include one or more of random access memory,pipes, sockets, semaphores, read only memory, and memory queues.